package com.chushouya.product.service.admin.impl;

import com.general.framework.core.enums.StatusEnum;
import com.general.framework.core.lang.Beans;
import com.general.framework.core.lang.Check;
import com.general.framework.core.lang.Dates;
import com.general.framework.core.schema.PageResult;
import com.chushouya.product.dao.entity.EvaluateItemEntity;
import com.chushouya.product.dao.entity.EvaluateItemValueEntity;
import com.chushouya.product.dao.repository.EvaluateItemRepository;
import com.chushouya.product.dao.repository.EvaluateItemValueRepository;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemCombineDTO;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemValueDetailDTO;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemValueListDTO;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemValueQuery;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemValueSaveDTO;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemValueUpdateDTO;
import com.chushouya.product.service.admin.EvaluateItemValueService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@Slf4j
public class EvaluateItemValueServiceImpl implements EvaluateItemValueService {

    @Resource
    private EvaluateItemValueRepository evaluateItemValueRepository;

    @Resource
    private EvaluateItemRepository evaluateItemRepository;

    /**
     * 获取估价项目
     */
    private EvaluateItemEntity getEvaluateItem(Long evaluateItemId) {
        Check.notNull(evaluateItemId, "evaluateItemId不能为空");
        EvaluateItemEntity entity = evaluateItemRepository.selectByPrimaryKey(evaluateItemId);
        Check.notNull(entity, "估价项目不存在");
        return entity;
    }

    @Override
    public PageResult<EvaluateItemValueListDTO> selectEvaluateItemValuePageResult(EvaluateItemValueQuery query) {
        PageResult<EvaluateItemValueEntity> pageResult = evaluateItemValueRepository.selectPageResult(query);
        return PageResult.of(pageResult, EvaluateItemValueListDTO.class);
    }

    @Override
    public List<EvaluateItemValueListDTO> selectEvaluateItemValueList(EvaluateItemValueQuery query) {
        List<EvaluateItemValueEntity> list = evaluateItemValueRepository.selectList(query);
        return Beans.copyList(list, EvaluateItemValueListDTO.class);
    }

    @Override
    public EvaluateItemValueDetailDTO getEvaluateItemValueDetail(Long evaluateValueId) {
        Check.notNull(evaluateValueId, "evaluateValueId can not be null");
        EvaluateItemValueEntity entity = evaluateItemValueRepository.selectByPrimaryKey(evaluateValueId);
        return Beans.copy(entity, EvaluateItemValueDetailDTO.class);
    }

    @Override
    public Long addEvaluateItemValue(EvaluateItemValueSaveDTO evaluateItemValue) {
        final Long evaluateItemId = evaluateItemValue.getEvaluateItemId();
        EvaluateItemEntity evaluateItem = getEvaluateItem(evaluateItemId);
        EvaluateItemValueEntity entity = Beans.copy(evaluateItemValue, EvaluateItemValueEntity.class);
        entity.setStatus(StatusEnum.normal.value());
        entity.setCreateTime(Dates.getTimeNow());
        entity.setEvaluateItemName(evaluateItem.getItemName());
        evaluateItemValueRepository.insertSelective(entity);
        return entity.getEvaluateValueId();
    }

    @Override
    public Long editEvaluateItemValue(EvaluateItemValueUpdateDTO evaluateItemValue) {
        final Long evaluateItemId = evaluateItemValue.getEvaluateItemId();
        EvaluateItemEntity evaluateItem = getEvaluateItem(evaluateItemId);
        EvaluateItemValueEntity existEntity = evaluateItemValueRepository.selectByPrimaryKey(evaluateItemValue.getEvaluateValueId());
        Check.notNull(existEntity, "估价项目选项不存在");
        
        EvaluateItemValueEntity updateEntity = Beans.copy(evaluateItemValue, EvaluateItemValueEntity.class);
        updateEntity.setEvaluateItemName(evaluateItem.getItemName());
        evaluateItemValueRepository.updateByPrimaryKeySelective(updateEntity);
        return updateEntity.getEvaluateValueId();
    }

    @Override
    public void removeEvaluateItemValue(Long evaluateValueId) {
        Check.notNull(evaluateValueId, "evaluateValueId can not be null");
        EvaluateItemValueEntity entity = evaluateItemValueRepository.selectByPrimaryKey(evaluateValueId);
        Check.notNull(entity, "估价项目选项不存在");


        evaluateItemValueRepository.deleteByPrimaryKey(evaluateValueId);
    }

    @Override
    public Long editEvaluateItemValueStatus(Long evaluateValueId, Integer status) {
        Check.notNull(evaluateValueId, "evaluateValueId can not be null");
        EvaluateItemValueEntity updateEntity = new EvaluateItemValueEntity();
        updateEntity.setEvaluateValueId(evaluateValueId);
        updateEntity.setStatus(status);
        evaluateItemValueRepository.updateByPrimaryKeySelective(updateEntity);
        return evaluateValueId;
    }

    @Override
    public List<EvaluateItemValueListDTO> selectEvaluateItemValueListByEvaluateItemId(Long evaluateItemId) {
        List<EvaluateItemValueEntity> list = evaluateItemValueRepository.selectListByEvaluateItemId(evaluateItemId);
        return Beans.copyList(list, EvaluateItemValueListDTO.class);
    }

    @Override
    public List<EvaluateItemCombineDTO> selectEvaluateItemCombineList(Long categoryId) {
        // 查询估价项目选项数据
        List<EvaluateItemValueEntity> allValueList;
        if (categoryId != null) {
            // 根据分类ID查询
            EvaluateItemValueQuery query = new EvaluateItemValueQuery();
            query.setCategoryId(categoryId);
            allValueList = evaluateItemValueRepository.selectList(query);
        } else {
            // 查询所有估价项目选项数据
            allValueList = evaluateItemValueRepository.selectAll();
        }
        
        // 按照 evaluateItemId 分组
        Map<Long, List<EvaluateItemValueEntity>> groupedMap = allValueList.stream()
                .collect(Collectors.groupingBy(
                        EvaluateItemValueEntity::getEvaluateItemId,
                        LinkedHashMap::new,
                        Collectors.toList()
                ));
        
        // 构建组合信息列表
        List<EvaluateItemCombineDTO> resultList = new ArrayList<>();
        
        for (Map.Entry<Long, List<EvaluateItemValueEntity>> entry : groupedMap.entrySet()) {
            Long evaluateItemId = entry.getKey();
            List<EvaluateItemValueEntity> valueList = entry.getValue();
            
            if (!valueList.isEmpty()) {
                EvaluateItemCombineDTO combineDTO = new EvaluateItemCombineDTO();
                combineDTO.setEvaluateItemId(evaluateItemId);
                combineDTO.setItemName(valueList.get(0).getEvaluateItemName()); // 取第一个的估价项目名称
                
                // 构建项目选项列表，按sort排序
                List<EvaluateItemCombineDTO.EvaluateValueInfo> evaluateValueList = valueList.stream()
                        .sorted((v1, v2) -> {
                            // 按sort字段升序排序，null值排在最后
                            if (v1.getSort() == null && v2.getSort() == null) return 0;
                            if (v1.getSort() == null) return 1;
                            if (v2.getSort() == null) return -1;
                            return v1.getSort().compareTo(v2.getSort());
                        })
                        .map(valueEntity -> {
                            EvaluateItemCombineDTO.EvaluateValueInfo valueInfo = 
                                    new EvaluateItemCombineDTO.EvaluateValueInfo();
                            valueInfo.setEvaluateValueId(valueEntity.getEvaluateValueId());
                            valueInfo.setValueContent(valueEntity.getValueContent());
                            return valueInfo;
                        })
                        .collect(Collectors.toList());
                
                combineDTO.setEvaluateValueList(evaluateValueList);
                resultList.add(combineDTO);
            }
        }
        
        return resultList;
    }
}
